'Weak Dependency Graph [60.0]' ------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , length(mark(X)) -> mark(length(X)) , proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , length(ok(X)) -> ok(length(X)) , top(mark(X)) -> top(proper(X)) , top(ok(X)) -> top(active(X))} Details: We have computed the following set of weak (innermost) dependency pairs: { active^#(zeros()) -> c_0(cons^#(0(), zeros())) , active^#(U11(tt(), L)) -> c_1(U12^#(tt(), L)) , active^#(U12(tt(), L)) -> c_2(s^#(length(L))) , active^#(length(nil())) -> c_3() , active^#(length(cons(N, L))) -> c_4(U11^#(tt(), L)) , active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2)) , active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2)) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2)) , active^#(s(X)) -> c_8(s^#(active(X))) , active^#(length(X)) -> c_9(length^#(active(X))) , cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2)) , U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2)) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2)) , s^#(mark(X)) -> c_13(s^#(X)) , length^#(mark(X)) -> c_14(length^#(X)) , proper^#(zeros()) -> c_15() , proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2))) , proper^#(0()) -> c_17() , proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2))) , proper^#(tt()) -> c_19() , proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2))) , proper^#(s(X)) -> c_21(s^#(proper(X))) , proper^#(length(X)) -> c_22(length^#(proper(X))) , proper^#(nil()) -> c_23() , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2)) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2)) , s^#(ok(X)) -> c_27(s^#(X)) , length^#(ok(X)) -> c_28(length^#(X)) , top^#(mark(X)) -> c_29(top^#(proper(X))) , top^#(ok(X)) -> c_30(top^#(active(X)))} The usable rules are: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} The estimated dependency graph contains the following edges: {active^#(U12(tt(), L)) -> c_2(s^#(length(L)))} ==> {s^#(ok(X)) -> c_27(s^#(X))} {active^#(U12(tt(), L)) -> c_2(s^#(length(L)))} ==> {s^#(mark(X)) -> c_13(s^#(X))} {active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} ==> {cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} {active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} ==> {cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} {active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} ==> {U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} {active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} ==> {U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} {active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} ==> {U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2))} {active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} ==> {U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} {active^#(s(X)) -> c_8(s^#(active(X)))} ==> {s^#(ok(X)) -> c_27(s^#(X))} {active^#(s(X)) -> c_8(s^#(active(X)))} ==> {s^#(mark(X)) -> c_13(s^#(X))} {active^#(length(X)) -> c_9(length^#(active(X)))} ==> {length^#(ok(X)) -> c_28(length^#(X))} {active^#(length(X)) -> c_9(length^#(active(X)))} ==> {length^#(mark(X)) -> c_14(length^#(X))} {cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} ==> {cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} {cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} ==> {cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} {U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} ==> {U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} {U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} ==> {U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} {U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} ==> {U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2))} {U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} ==> {U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} {s^#(mark(X)) -> c_13(s^#(X))} ==> {s^#(ok(X)) -> c_27(s^#(X))} {s^#(mark(X)) -> c_13(s^#(X))} ==> {s^#(mark(X)) -> c_13(s^#(X))} {length^#(mark(X)) -> c_14(length^#(X))} ==> {length^#(ok(X)) -> c_28(length^#(X))} {length^#(mark(X)) -> c_14(length^#(X))} ==> {length^#(mark(X)) -> c_14(length^#(X))} {proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2)))} ==> {cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} {proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2)))} ==> {cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} {proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2)))} ==> {U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} {proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2)))} ==> {U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} {proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2)))} ==> {U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2))} {proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2)))} ==> {U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} {proper^#(s(X)) -> c_21(s^#(proper(X)))} ==> {s^#(ok(X)) -> c_27(s^#(X))} {proper^#(s(X)) -> c_21(s^#(proper(X)))} ==> {s^#(mark(X)) -> c_13(s^#(X))} {proper^#(length(X)) -> c_22(length^#(proper(X)))} ==> {length^#(ok(X)) -> c_28(length^#(X))} {proper^#(length(X)) -> c_22(length^#(proper(X)))} ==> {length^#(mark(X)) -> c_14(length^#(X))} {cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} ==> {cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} {cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} ==> {cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} {U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} ==> {U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} {U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} ==> {U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} {U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2))} ==> {U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2))} {U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2))} ==> {U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} {s^#(ok(X)) -> c_27(s^#(X))} ==> {s^#(ok(X)) -> c_27(s^#(X))} {s^#(ok(X)) -> c_27(s^#(X))} ==> {s^#(mark(X)) -> c_13(s^#(X))} {length^#(ok(X)) -> c_28(length^#(X))} ==> {length^#(ok(X)) -> c_28(length^#(X))} {length^#(ok(X)) -> c_28(length^#(X))} ==> {length^#(mark(X)) -> c_14(length^#(X))} {top^#(mark(X)) -> c_29(top^#(proper(X)))} ==> {top^#(ok(X)) -> c_30(top^#(active(X)))} {top^#(mark(X)) -> c_29(top^#(proper(X)))} ==> {top^#(mark(X)) -> c_29(top^#(proper(X)))} {top^#(ok(X)) -> c_30(top^#(active(X)))} ==> {top^#(ok(X)) -> c_30(top^#(active(X)))} {top^#(ok(X)) -> c_30(top^#(active(X)))} ==> {top^#(mark(X)) -> c_29(top^#(proper(X)))} We consider the following path(s): 1) { top^#(mark(X)) -> c_29(top^#(proper(X))) , top^#(ok(X)) -> c_30(top^#(active(X)))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , top^#(mark(X)) -> c_29(top^#(proper(X))) , top^#(ok(X)) -> c_30(top^#(active(X)))} Details: We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [0] c_29(x1) = [1] x1 + [0] c_30(x1) = [1] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , top^#(ok(X)) -> c_30(top^#(active(X)))} and weakly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , top^#(ok(X)) -> c_30(top^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [9] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [0] c_29(x1) = [1] x1 + [0] c_30(x1) = [1] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , top^#(ok(X)) -> c_30(top^#(active(X))) , proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [12] length(x1) = [1] x1 + [0] nil() = [6] proper(x1) = [1] x1 + [4] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [0] c_29(x1) = [1] x1 + [13] c_30(x1) = [1] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), L)) -> mark(s(length(L)))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , top^#(ok(X)) -> c_30(top^#(active(X))) , proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), L)) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [3] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [7] c_29(x1) = [1] x1 + [0] c_30(x1) = [1] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(cons(N, L))) -> mark(U11(tt(), L))} and weakly orienting the rules { active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , top^#(ok(X)) -> c_30(top^#(active(X))) , proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(cons(N, L))) -> mark(U11(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [4] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [2] nil() = [1] proper(x1) = [1] x1 + [7] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [1] c_29(x1) = [1] x1 + [0] c_30(x1) = [1] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), L)) -> mark(U12(tt(), L))} and weakly orienting the rules { active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , top^#(ok(X)) -> c_30(top^#(active(X))) , proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), L)) -> mark(U12(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [4] zeros() = [6] mark(x1) = [1] x1 + [3] cons(x1, x2) = [1] x1 + [1] x2 + [5] 0() = [9] U11(x1, x2) = [1] x1 + [1] x2 + [5] tt() = [1] U12(x1, x2) = [1] x1 + [1] x2 + [5] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [12] proper(x1) = [1] x1 + [13] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [1] c_29(x1) = [1] x1 + [0] c_30(x1) = [1] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {top^#(mark(X)) -> c_29(top^#(proper(X)))} and weakly orienting the rules { active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , top^#(ok(X)) -> c_30(top^#(active(X))) , proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {top^#(mark(X)) -> c_29(top^#(proper(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [2] cons(x1, x2) = [1] x1 + [1] x2 + [8] 0() = [6] U11(x1, x2) = [1] x1 + [1] x2 + [2] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [1] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [15] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [1] c_29(x1) = [1] x1 + [0] c_30(x1) = [1] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { top^#(mark(X)) -> c_29(top^#(proper(X))) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , top^#(ok(X)) -> c_30(top^#(active(X))) , proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { top^#(mark(X)) -> c_29(top^#(proper(X))) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , top^#(ok(X)) -> c_30(top^#(active(X))) , proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: The problem is Match-bounded by 4. The enriched problem is compatible with the following automaton: { active_0(2) -> 6 , active_1(2) -> 15 , active_2(8) -> 21 , active_2(9) -> 21 , active_2(24) -> 28 , active_3(23) -> 29 , active_3(24) -> 35 , active_3(38) -> 40 , active_4(37) -> 41 , active_4(38) -> 43 , zeros_0() -> 2 , zeros_1() -> 9 , zeros_2() -> 22 , zeros_3() -> 36 , mark_0(2) -> 2 , mark_1(7) -> 6 , mark_1(7) -> 15 , mark_2(24) -> 21 , cons_1(8, 9) -> 7 , cons_2(16, 17) -> 13 , cons_2(16, 17) -> 19 , cons_2(23, 22) -> 24 , cons_3(29, 22) -> 28 , cons_3(29, 22) -> 35 , cons_3(30, 31) -> 26 , cons_3(30, 31) -> 33 , cons_3(37, 36) -> 38 , cons_4(41, 36) -> 40 , cons_4(41, 36) -> 43 , 0_0() -> 2 , 0_1() -> 8 , 0_2() -> 23 , 0_3() -> 37 , tt_0() -> 2 , tt_1() -> 8 , tt_2() -> 23 , tt_3() -> 37 , nil_0() -> 2 , nil_1() -> 8 , nil_2() -> 23 , nil_3() -> 37 , proper_0(2) -> 4 , proper_1(2) -> 11 , proper_1(7) -> 13 , proper_2(7) -> 19 , proper_2(8) -> 16 , proper_2(9) -> 17 , proper_2(24) -> 26 , proper_3(22) -> 31 , proper_3(23) -> 30 , proper_3(24) -> 33 , ok_0(2) -> 2 , ok_0(2) -> 4 , ok_1(8) -> 11 , ok_1(9) -> 11 , ok_2(22) -> 17 , ok_2(23) -> 16 , ok_2(24) -> 13 , ok_2(24) -> 19 , ok_3(36) -> 31 , ok_3(37) -> 30 , ok_3(38) -> 26 , ok_3(38) -> 33 , top^#_0(2) -> 1 , top^#_0(4) -> 3 , top^#_0(6) -> 5 , top^#_1(11) -> 10 , top^#_1(13) -> 12 , top^#_1(15) -> 14 , top^#_2(19) -> 18 , top^#_2(21) -> 20 , top^#_2(26) -> 25 , top^#_2(28) -> 27 , top^#_3(33) -> 32 , top^#_3(35) -> 34 , top^#_3(40) -> 39 , top^#_4(43) -> 42 , c_29_0(3) -> 1 , c_29_1(10) -> 1 , c_29_1(12) -> 5 , c_29_2(18) -> 14 , c_29_2(25) -> 20 , c_29_3(32) -> 20 , c_30_0(5) -> 1 , c_30_1(14) -> 1 , c_30_1(14) -> 3 , c_30_2(20) -> 10 , c_30_2(27) -> 12 , c_30_2(27) -> 18 , c_30_3(34) -> 18 , c_30_3(39) -> 25 , c_30_3(39) -> 32 , c_30_4(42) -> 32} 2) { active^#(length(X)) -> c_9(length^#(active(X))) , length^#(ok(X)) -> c_28(length^#(X)) , length^#(mark(X)) -> c_14(length^#(X))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(length(X)) -> c_9(length^#(active(X))) , length^#(ok(X)) -> c_28(length^#(X)) , length^#(mark(X)) -> c_14(length^#(X))} Details: We apply the weight gap principle, strictly orienting the rules {length^#(mark(X)) -> c_14(length^#(X))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {length^#(mark(X)) -> c_14(length^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] length^#(x1) = [1] x1 + [12] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [1] x1 + [5] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), L)) -> mark(s(length(L)))} and weakly orienting the rules {length^#(mark(X)) -> c_14(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), L)) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [4] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] length^#(x1) = [1] x1 + [8] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [1] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(length(X)) -> c_9(length^#(active(X)))} and weakly orienting the rules { active(U12(tt(), L)) -> mark(s(length(L))) , length^#(mark(X)) -> c_14(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(length(X)) -> c_9(length^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [3] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [1] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , length^#(ok(X)) -> c_28(length^#(X))} and weakly orienting the rules { active^#(length(X)) -> c_9(length^#(active(X))) , active(U12(tt(), L)) -> mark(s(length(L))) , length^#(mark(X)) -> c_14(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , length^#(ok(X)) -> c_28(length^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [7] length^#(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , length^#(ok(X)) -> c_28(length^#(X)) , active^#(length(X)) -> c_9(length^#(active(X))) , active(U12(tt(), L)) -> mark(s(length(L))) , length^#(mark(X)) -> c_14(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [11] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] length^#(x1) = [1] x1 + [7] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(cons(N, L))) -> mark(U11(tt(), L))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , length^#(ok(X)) -> c_28(length^#(X)) , active^#(length(X)) -> c_9(length^#(active(X))) , active(U12(tt(), L)) -> mark(s(length(L))) , length^#(mark(X)) -> c_14(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(cons(N, L))) -> mark(U11(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [8] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [3] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [5] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [1] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), L)) -> mark(U12(tt(), L))} and weakly orienting the rules { active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , length^#(ok(X)) -> c_28(length^#(X)) , active^#(length(X)) -> c_9(length^#(active(X))) , active(U12(tt(), L)) -> mark(s(length(L))) , length^#(mark(X)) -> c_14(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), L)) -> mark(U12(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [0] zeros() = [2] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [2] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [1] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [10] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [5] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(zeros()) -> mark(cons(0(), zeros()))} and weakly orienting the rules { active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , length^#(ok(X)) -> c_28(length^#(X)) , active^#(length(X)) -> c_9(length^#(active(X))) , active(U12(tt(), L)) -> mark(s(length(L))) , length^#(mark(X)) -> c_14(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(zeros()) -> mark(cons(0(), zeros()))} Details: Interpretation Functions: active(x1) = [1] x1 + [4] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [2] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [9] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , length^#(ok(X)) -> c_28(length^#(X)) , active^#(length(X)) -> c_9(length^#(active(X))) , active(U12(tt(), L)) -> mark(s(length(L))) , length^#(mark(X)) -> c_14(length^#(X))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , length^#(ok(X)) -> c_28(length^#(X)) , active^#(length(X)) -> c_9(length^#(active(X))) , active(U12(tt(), L)) -> mark(s(length(L))) , length^#(mark(X)) -> c_14(length^#(X))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(11) -> 3 , mark_0(13) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 11 , ok_0(2) -> 13 , ok_0(3) -> 13 , ok_0(5) -> 13 , ok_0(7) -> 13 , ok_0(11) -> 13 , ok_0(13) -> 13 , active^#_0(2) -> 15 , active^#_0(3) -> 15 , active^#_0(5) -> 15 , active^#_0(7) -> 15 , active^#_0(11) -> 15 , active^#_0(13) -> 15 , length^#_0(2) -> 30 , length^#_0(3) -> 30 , length^#_0(5) -> 30 , length^#_0(7) -> 30 , length^#_0(11) -> 30 , length^#_0(13) -> 30 , c_14_0(30) -> 30 , c_28_0(30) -> 30} 3) { active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2)) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2)) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2)) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2)) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules {U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [8] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [1] x1 + [1] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(U12(tt(), L)) -> mark(s(length(L))) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} and weakly orienting the rules {U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(U12(tt(), L)) -> mark(s(length(L))) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [8] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [1] x1 + [1] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2))} and weakly orienting the rules { active(U12(tt(), L)) -> mark(s(length(L))) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2)) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [3] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [14] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [1] x1 + [4] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2)) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [12] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [4] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [1] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(cons(N, L))) -> mark(U11(tt(), L))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2)) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(cons(N, L))) -> mark(U11(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [4] s(x1) = [1] x1 + [2] length(x1) = [1] x1 + [2] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [15] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [1] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), L)) -> mark(U12(tt(), L))} and weakly orienting the rules { active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2)) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), L)) -> mark(U12(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [8] zeros() = [8] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [8] 0() = [9] U11(x1, x2) = [1] x1 + [1] x2 + [4] tt() = [4] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [12] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [2] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [1] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [1] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(zeros()) -> mark(cons(0(), zeros()))} and weakly orienting the rules { active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2)) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(zeros()) -> mark(cons(0(), zeros()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [1] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [1] s(x1) = [1] x1 + [1] length(x1) = [1] x1 + [0] nil() = [3] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [15] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [1] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2)) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2)) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , tt_0() -> 2 , nil_0() -> 2 , ok_0(2) -> 2 , active^#_0(2) -> 1 , U12^#_0(2, 2) -> 1 , c_12_0(1) -> 1 , c_26_0(1) -> 1} 4) { active^#(s(X)) -> c_8(s^#(active(X))) , s^#(ok(X)) -> c_27(s^#(X)) , s^#(mark(X)) -> c_13(s^#(X))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(s(X)) -> c_8(s^#(active(X))) , s^#(ok(X)) -> c_27(s^#(X)) , s^#(mark(X)) -> c_13(s^#(X))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s^#(ok(X)) -> c_27(s^#(X))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s^#(ok(X)) -> c_27(s^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [10] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [1] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {s^#(mark(X)) -> c_13(s^#(X))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s^#(ok(X)) -> c_27(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {s^#(mark(X)) -> c_13(s^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(s(X)) -> c_8(s^#(active(X)))} and weakly orienting the rules { s^#(mark(X)) -> c_13(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s^#(ok(X)) -> c_27(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(s(X)) -> c_8(s^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [1] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [1] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { active^#(s(X)) -> c_8(s^#(active(X))) , s^#(mark(X)) -> c_13(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s^#(ok(X)) -> c_27(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(cons(N, L))) -> mark(U11(tt(), L))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_8(s^#(active(X))) , s^#(mark(X)) -> c_13(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s^#(ok(X)) -> c_27(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(cons(N, L))) -> mark(U11(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [4] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [4] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [8] s(x1) = [1] x1 + [12] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [12] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [12] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [1] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [4] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), L)) -> mark(U12(tt(), L))} and weakly orienting the rules { active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_8(s^#(active(X))) , s^#(mark(X)) -> c_13(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s^#(ok(X)) -> c_27(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), L)) -> mark(U12(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [2] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [15] 0() = [8] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [3] nil() = [12] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [8] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [3] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(zeros()) -> mark(cons(0(), zeros())) , active(U12(tt(), L)) -> mark(s(length(L)))} and weakly orienting the rules { active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_8(s^#(active(X))) , s^#(mark(X)) -> c_13(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s^#(ok(X)) -> c_27(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(zeros()) -> mark(cons(0(), zeros())) , active(U12(tt(), L)) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [9] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [3] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [2] U12(x1, x2) = [1] x1 + [1] x2 + [5] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U12(tt(), L)) -> mark(s(length(L))) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_8(s^#(active(X))) , s^#(mark(X)) -> c_13(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s^#(ok(X)) -> c_27(s^#(X))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U12(tt(), L)) -> mark(s(length(L))) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_8(s^#(active(X))) , s^#(mark(X)) -> c_13(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s^#(ok(X)) -> c_27(s^#(X))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(11) -> 3 , mark_0(13) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 11 , ok_0(2) -> 13 , ok_0(3) -> 13 , ok_0(5) -> 13 , ok_0(7) -> 13 , ok_0(11) -> 13 , ok_0(13) -> 13 , active^#_0(2) -> 15 , active^#_0(3) -> 15 , active^#_0(5) -> 15 , active^#_0(7) -> 15 , active^#_0(11) -> 15 , active^#_0(13) -> 15 , s^#_0(2) -> 21 , s^#_0(3) -> 21 , s^#_0(5) -> 21 , s^#_0(7) -> 21 , s^#_0(11) -> 21 , s^#_0(13) -> 21 , c_13_0(21) -> 21 , c_27_0(21) -> 21} 5) { active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2)) , cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2)) , cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules {cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [1] x1 + [1] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), L)) -> mark(s(length(L)))} and weakly orienting the rules {cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), L)) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [8] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [3] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [1] x1 + [1] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} and weakly orienting the rules { active(U12(tt(), L)) -> mark(s(length(L))) , cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [9] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [5] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [2] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [1] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [1] x1 + [1] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [1] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), L)) -> mark(U12(tt(), L))} and weakly orienting the rules { active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2)) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), L)) -> mark(U12(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [8] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [2] tt() = [6] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [3] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [1] x1 + [1] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(zeros()) -> mark(cons(0(), zeros()))} and weakly orienting the rules { active(U11(tt(), L)) -> mark(U12(tt(), L)) , active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2)) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(zeros()) -> mark(cons(0(), zeros()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [4] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2)) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2)) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , tt_0() -> 2 , nil_0() -> 2 , ok_0(2) -> 2 , active^#_0(2) -> 1 , cons^#_0(2, 2) -> 1 , c_10_0(1) -> 1 , c_24_0(1) -> 1} 6) {active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} Details: We apply the weight gap principle, strictly orienting the rules {active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} and weakly orienting the rules {active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [12] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [8] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [7] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(cons(N, L))) -> mark(U11(tt(), L))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(cons(N, L))) -> mark(U11(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [2] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [7] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), L)) -> mark(s(length(L)))} and weakly orienting the rules { active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), L)) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [7] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [9] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(zeros()) -> mark(cons(0(), zeros()))} and weakly orienting the rules { active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(zeros()) -> mark(cons(0(), zeros()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [4] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [15] s(x1) = [1] x1 + [13] length(x1) = [1] x1 + [1] nil() = [9] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), L)) -> mark(U12(tt(), L))} and weakly orienting the rules { active(zeros()) -> mark(cons(0(), zeros())) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), L)) -> mark(U12(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [15] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(zeros()) -> mark(cons(0(), zeros())) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(zeros()) -> mark(cons(0(), zeros())) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(11) -> 3 , mark_0(13) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 11 , ok_0(2) -> 13 , ok_0(3) -> 13 , ok_0(5) -> 13 , ok_0(7) -> 13 , ok_0(11) -> 13 , ok_0(13) -> 13 , active^#_0(2) -> 15 , active^#_0(3) -> 15 , active^#_0(5) -> 15 , active^#_0(7) -> 15 , active^#_0(11) -> 15 , active^#_0(13) -> 15 , U11^#_0(2, 2) -> 24 , U11^#_0(2, 3) -> 24 , U11^#_0(2, 5) -> 24 , U11^#_0(2, 7) -> 24 , U11^#_0(2, 11) -> 24 , U11^#_0(2, 13) -> 24 , U11^#_0(3, 2) -> 24 , U11^#_0(3, 3) -> 24 , U11^#_0(3, 5) -> 24 , U11^#_0(3, 7) -> 24 , U11^#_0(3, 11) -> 24 , U11^#_0(3, 13) -> 24 , U11^#_0(5, 2) -> 24 , U11^#_0(5, 3) -> 24 , U11^#_0(5, 5) -> 24 , U11^#_0(5, 7) -> 24 , U11^#_0(5, 11) -> 24 , U11^#_0(5, 13) -> 24 , U11^#_0(7, 2) -> 24 , U11^#_0(7, 3) -> 24 , U11^#_0(7, 5) -> 24 , U11^#_0(7, 7) -> 24 , U11^#_0(7, 11) -> 24 , U11^#_0(7, 13) -> 24 , U11^#_0(11, 2) -> 24 , U11^#_0(11, 3) -> 24 , U11^#_0(11, 5) -> 24 , U11^#_0(11, 7) -> 24 , U11^#_0(11, 11) -> 24 , U11^#_0(11, 13) -> 24 , U11^#_0(13, 2) -> 24 , U11^#_0(13, 3) -> 24 , U11^#_0(13, 5) -> 24 , U11^#_0(13, 7) -> 24 , U11^#_0(13, 11) -> 24 , U11^#_0(13, 13) -> 24} 7) {active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} Details: We apply the weight gap principle, strictly orienting the rules {active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [5] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [1] x1 + [1] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} and weakly orienting the rules {active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(cons(N, L))) -> mark(U11(tt(), L))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(cons(N, L))) -> mark(U11(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [2] nil() = [14] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [5] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), L)) -> mark(s(length(L)))} and weakly orienting the rules { active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), L)) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [7] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [5] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), L)) -> mark(U12(tt(), L))} and weakly orienting the rules { active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), L)) -> mark(U12(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [1] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [1] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [3] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [15] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [8] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [1] x1 + [8] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(zeros()) -> mark(cons(0(), zeros()))} and weakly orienting the rules { active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(zeros()) -> mark(cons(0(), zeros()))} Details: Interpretation Functions: active(x1) = [1] x1 + [8] zeros() = [0] mark(x1) = [1] x1 + [4] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [1] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(cons(X1, X2)) -> c_5(cons^#(active(X1), X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , tt_0() -> 2 , nil_0() -> 2 , ok_0(2) -> 2 , active^#_0(2) -> 1 , cons^#_0(2, 2) -> 1} 8) { active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2)) , U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2)) , U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules {U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [8] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [1] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), L)) -> mark(s(length(L)))} and weakly orienting the rules {U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), L)) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [8] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [1] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} and weakly orienting the rules { active(U12(tt(), L)) -> mark(s(length(L))) , U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [9] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [5] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [1] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L))} and weakly orienting the rules { active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2)) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [1] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [1] nil() = [8] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2)) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active^#(U11(X1, X2)) -> c_6(U11^#(active(X1), X2)) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2)) , active(U12(tt(), L)) -> mark(s(length(L))) , U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , tt_0() -> 2 , nil_0() -> 2 , ok_0(2) -> 2 , active^#_0(2) -> 1 , U11^#_0(2, 2) -> 1 , c_11_0(1) -> 1 , c_25_0(1) -> 1} 9) {active^#(length(X)) -> c_9(length^#(active(X)))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(length(X)) -> c_9(length^#(active(X)))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(length(X)) -> c_9(length^#(active(X)))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(length(X)) -> c_9(length^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { active^#(length(X)) -> c_9(length^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [3] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(cons(N, L))) -> mark(U11(tt(), L))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , active^#(length(X)) -> c_9(length^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(cons(N, L))) -> mark(U11(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [2] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), L)) -> mark(s(length(L)))} and weakly orienting the rules { active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , active^#(length(X)) -> c_9(length^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), L)) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [7] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L))} and weakly orienting the rules { active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , active^#(length(X)) -> c_9(length^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [2] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , active^#(length(X)) -> c_9(length^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , active^#(length(X)) -> c_9(length^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(11) -> 3 , mark_0(13) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 11 , ok_0(2) -> 13 , ok_0(3) -> 13 , ok_0(5) -> 13 , ok_0(7) -> 13 , ok_0(11) -> 13 , ok_0(13) -> 13 , active^#_0(2) -> 15 , active^#_0(3) -> 15 , active^#_0(5) -> 15 , active^#_0(7) -> 15 , active^#_0(11) -> 15 , active^#_0(13) -> 15 , length^#_0(2) -> 30 , length^#_0(3) -> 30 , length^#_0(5) -> 30 , length^#_0(7) -> 30 , length^#_0(11) -> 30 , length^#_0(13) -> 30} 10) {active^#(s(X)) -> c_8(s^#(active(X)))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(s(X)) -> c_8(s^#(active(X)))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(s(X)) -> c_8(s^#(active(X)))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(s(X)) -> c_8(s^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { active^#(s(X)) -> c_8(s^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [1] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(cons(N, L))) -> mark(U11(tt(), L))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_8(s^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(cons(N, L))) -> mark(U11(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [14] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [1] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), L)) -> mark(s(length(L)))} and weakly orienting the rules { active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_8(s^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), L)) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [7] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L))} and weakly orienting the rules { active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_8(s^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [4] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_8(s^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_8(s^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(11) -> 3 , mark_0(13) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 11 , ok_0(2) -> 13 , ok_0(3) -> 13 , ok_0(5) -> 13 , ok_0(7) -> 13 , ok_0(11) -> 13 , ok_0(13) -> 13 , active^#_0(2) -> 15 , active^#_0(3) -> 15 , active^#_0(5) -> 15 , active^#_0(7) -> 15 , active^#_0(11) -> 15 , active^#_0(13) -> 15 , s^#_0(2) -> 21 , s^#_0(3) -> 21 , s^#_0(5) -> 21 , s^#_0(7) -> 21 , s^#_0(11) -> 21 , s^#_0(13) -> 21} 11) {active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [3] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(cons(N, L))) -> mark(U11(tt(), L))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(cons(N, L))) -> mark(U11(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [2] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [7] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U12(tt(), L)) -> mark(s(length(L)))} and weakly orienting the rules { active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U12(tt(), L)) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [7] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [9] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(zeros()) -> mark(cons(0(), zeros()))} and weakly orienting the rules { active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(zeros()) -> mark(cons(0(), zeros()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [1] U12(x1, x2) = [1] x1 + [1] x2 + [12] s(x1) = [1] x1 + [13] length(x1) = [1] x1 + [1] nil() = [9] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(U11(tt(), L)) -> mark(U12(tt(), L))} and weakly orienting the rules { active(zeros()) -> mark(cons(0(), zeros())) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(U11(tt(), L)) -> mark(U12(tt(), L))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [15] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(zeros()) -> mark(cons(0(), zeros())) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(U11(X1, X2)) -> U11(active(X1), X2) , active(U12(X1, X2)) -> U12(active(X1), X2) , active(s(X)) -> s(active(X)) , active(length(X)) -> length(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(U11(tt(), L)) -> mark(U12(tt(), L)) , active(zeros()) -> mark(cons(0(), zeros())) , active(U12(tt(), L)) -> mark(s(length(L))) , active(length(cons(N, L))) -> mark(U11(tt(), L)) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , active^#(U12(X1, X2)) -> c_7(U12^#(active(X1), X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(11) -> 3 , mark_0(13) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 11 , ok_0(2) -> 13 , ok_0(3) -> 13 , ok_0(5) -> 13 , ok_0(7) -> 13 , ok_0(11) -> 13 , ok_0(13) -> 13 , active^#_0(2) -> 15 , active^#_0(3) -> 15 , active^#_0(5) -> 15 , active^#_0(7) -> 15 , active^#_0(11) -> 15 , active^#_0(13) -> 15 , U12^#_0(2, 2) -> 19 , U12^#_0(2, 3) -> 19 , U12^#_0(2, 5) -> 19 , U12^#_0(2, 7) -> 19 , U12^#_0(2, 11) -> 19 , U12^#_0(2, 13) -> 19 , U12^#_0(3, 2) -> 19 , U12^#_0(3, 3) -> 19 , U12^#_0(3, 5) -> 19 , U12^#_0(3, 7) -> 19 , U12^#_0(3, 11) -> 19 , U12^#_0(3, 13) -> 19 , U12^#_0(5, 2) -> 19 , U12^#_0(5, 3) -> 19 , U12^#_0(5, 5) -> 19 , U12^#_0(5, 7) -> 19 , U12^#_0(5, 11) -> 19 , U12^#_0(5, 13) -> 19 , U12^#_0(7, 2) -> 19 , U12^#_0(7, 3) -> 19 , U12^#_0(7, 5) -> 19 , U12^#_0(7, 7) -> 19 , U12^#_0(7, 11) -> 19 , U12^#_0(7, 13) -> 19 , U12^#_0(11, 2) -> 19 , U12^#_0(11, 3) -> 19 , U12^#_0(11, 5) -> 19 , U12^#_0(11, 7) -> 19 , U12^#_0(11, 11) -> 19 , U12^#_0(11, 13) -> 19 , U12^#_0(13, 2) -> 19 , U12^#_0(13, 3) -> 19 , U12^#_0(13, 5) -> 19 , U12^#_0(13, 7) -> 19 , U12^#_0(13, 11) -> 19 , U12^#_0(13, 13) -> 19} 12) { proper^#(s(X)) -> c_21(s^#(proper(X))) , s^#(ok(X)) -> c_27(s^#(X)) , s^#(mark(X)) -> c_13(s^#(X))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(s(X)) -> c_21(s^#(proper(X))) , s^#(ok(X)) -> c_27(s^#(X)) , s^#(mark(X)) -> c_13(s^#(X))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [8] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [1] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {s^#(ok(X)) -> c_27(s^#(X))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {s^#(ok(X)) -> c_27(s^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [1] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [3] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(s(X)) -> c_21(s^#(proper(X)))} and weakly orienting the rules { s^#(ok(X)) -> c_27(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(s(X)) -> c_21(s^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [1] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {s^#(mark(X)) -> c_13(s^#(X))} and weakly orienting the rules { proper^#(s(X)) -> c_21(s^#(proper(X))) , s^#(ok(X)) -> c_27(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {s^#(mark(X)) -> c_13(s^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [8] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [8] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [1] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { s^#(mark(X)) -> c_13(s^#(X)) , proper^#(s(X)) -> c_21(s^#(proper(X))) , s^#(ok(X)) -> c_27(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [4] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [4] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [13] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [7] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , s^#(mark(X)) -> c_13(s^#(X)) , proper^#(s(X)) -> c_21(s^#(proper(X))) , s^#(ok(X)) -> c_27(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , s^#(mark(X)) -> c_13(s^#(X)) , proper^#(s(X)) -> c_21(s^#(proper(X))) , s^#(ok(X)) -> c_27(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(11) -> 3 , mark_0(13) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 11 , ok_0(2) -> 13 , ok_0(3) -> 13 , ok_0(5) -> 13 , ok_0(7) -> 13 , ok_0(11) -> 13 , ok_0(13) -> 13 , s^#_0(2) -> 21 , s^#_0(3) -> 21 , s^#_0(5) -> 21 , s^#_0(7) -> 21 , s^#_0(11) -> 21 , s^#_0(13) -> 21 , c_13_0(21) -> 21 , proper^#_0(2) -> 36 , proper^#_0(3) -> 36 , proper^#_0(5) -> 36 , proper^#_0(7) -> 36 , proper^#_0(11) -> 36 , proper^#_0(13) -> 36 , c_27_0(21) -> 21} 13) { proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2))) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2)) , U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2))) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2)) , U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [4] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [1] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [1] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [4] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [8] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [4] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [1] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [1] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2)))} and weakly orienting the rules { U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [1] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [1] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2))) , U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [3] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [8] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [1] length(x1) = [1] x1 + [8] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [1] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [5] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [2] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [1] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2))) , U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2))) , U11^#(mark(X1), X2) -> c_11(U11^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , U11^#(ok(X1), ok(X2)) -> c_25(U11^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , tt_0() -> 2 , nil_0() -> 2 , ok_0(2) -> 2 , U11^#_0(2, 2) -> 1 , c_11_0(1) -> 1 , proper^#_0(2) -> 1 , c_25_0(1) -> 1} 14) { proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2))) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2)) , cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2))) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2)) , cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [4] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [1] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [1] x1 + [1] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [1] x1 + [1] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [4] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [8] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [4] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [1] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [1] x1 + [1] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [1] x1 + [1] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2)))} and weakly orienting the rules { cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_15() = [0] c_16(x1) = [1] x1 + [1] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [1] x1 + [1] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2))) , cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [2] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [2] s(x1) = [1] x1 + [4] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [4] c_15() = [0] c_16(x1) = [1] x1 + [1] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2))) , cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2))) , cons^#(mark(X1), X2) -> c_10(cons^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_24(cons^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , tt_0() -> 2 , nil_0() -> 2 , ok_0(2) -> 2 , cons^#_0(2, 2) -> 1 , c_10_0(1) -> 1 , proper^#_0(2) -> 1 , c_24_0(1) -> 1} 15) { proper^#(length(X)) -> c_22(length^#(proper(X))) , length^#(ok(X)) -> c_28(length^#(X)) , length^#(mark(X)) -> c_14(length^#(X))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(length(X)) -> c_22(length^#(proper(X))) , length^#(ok(X)) -> c_28(length^#(X)) , length^#(mark(X)) -> c_14(length^#(X))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [1] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { length^#(ok(X)) -> c_28(length^#(X)) , length^#(mark(X)) -> c_14(length^#(X))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { length^#(ok(X)) -> c_28(length^#(X)) , length^#(mark(X)) -> c_14(length^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [9] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(length(X)) -> c_22(length^#(proper(X)))} and weakly orienting the rules { length^#(ok(X)) -> c_28(length^#(X)) , length^#(mark(X)) -> c_14(length^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(length(X)) -> c_22(length^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [4] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] proper^#(x1) = [1] x1 + [9] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [3] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { proper^#(length(X)) -> c_22(length^#(proper(X))) , length^#(ok(X)) -> c_28(length^#(X)) , length^#(mark(X)) -> c_14(length^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [1] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [1] x1 + [0] proper^#(x1) = [1] x1 + [2] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(length(X)) -> c_22(length^#(proper(X))) , length^#(ok(X)) -> c_28(length^#(X)) , length^#(mark(X)) -> c_14(length^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(length(X)) -> c_22(length^#(proper(X))) , length^#(ok(X)) -> c_28(length^#(X)) , length^#(mark(X)) -> c_14(length^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(11) -> 3 , mark_0(13) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 11 , ok_0(2) -> 13 , ok_0(3) -> 13 , ok_0(5) -> 13 , ok_0(7) -> 13 , ok_0(11) -> 13 , ok_0(13) -> 13 , length^#_0(2) -> 30 , length^#_0(3) -> 30 , length^#_0(5) -> 30 , length^#_0(7) -> 30 , length^#_0(11) -> 30 , length^#_0(13) -> 30 , c_14_0(30) -> 30 , proper^#_0(2) -> 36 , proper^#_0(3) -> 36 , proper^#_0(5) -> 36 , proper^#_0(7) -> 36 , proper^#_0(11) -> 36 , proper^#_0(13) -> 36 , c_28_0(30) -> 30} 16) { proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2))) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2)) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2))) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2)) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2))) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2))) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [4] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [1] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [1] x1 + [1] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2))) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [4] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [15] s(x1) = [1] x1 + [1] length(x1) = [1] x1 + [4] nil() = [8] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [4] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [1] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [13] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [12] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [1] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2))) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , U12^#(mark(X1), X2) -> c_12(U12^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2))) , U12^#(ok(X1), ok(X2)) -> c_26(U12^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , tt_0() -> 2 , nil_0() -> 2 , ok_0(2) -> 2 , U12^#_0(2, 2) -> 1 , c_12_0(1) -> 1 , proper^#_0(2) -> 1 , c_26_0(1) -> 1} 17) {proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2)))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2)))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [1] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2)))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [1] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [2] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [3] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [1] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(U11(X1, X2)) -> c_18(U11^#(proper(X1), proper(X2))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(11) -> 3 , mark_0(13) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 11 , ok_0(2) -> 13 , ok_0(3) -> 13 , ok_0(5) -> 13 , ok_0(7) -> 13 , ok_0(11) -> 13 , ok_0(13) -> 13 , U11^#_0(2, 2) -> 24 , U11^#_0(2, 3) -> 24 , U11^#_0(2, 5) -> 24 , U11^#_0(2, 7) -> 24 , U11^#_0(2, 11) -> 24 , U11^#_0(2, 13) -> 24 , U11^#_0(3, 2) -> 24 , U11^#_0(3, 3) -> 24 , U11^#_0(3, 5) -> 24 , U11^#_0(3, 7) -> 24 , U11^#_0(3, 11) -> 24 , U11^#_0(3, 13) -> 24 , U11^#_0(5, 2) -> 24 , U11^#_0(5, 3) -> 24 , U11^#_0(5, 5) -> 24 , U11^#_0(5, 7) -> 24 , U11^#_0(5, 11) -> 24 , U11^#_0(5, 13) -> 24 , U11^#_0(7, 2) -> 24 , U11^#_0(7, 3) -> 24 , U11^#_0(7, 5) -> 24 , U11^#_0(7, 7) -> 24 , U11^#_0(7, 11) -> 24 , U11^#_0(7, 13) -> 24 , U11^#_0(11, 2) -> 24 , U11^#_0(11, 3) -> 24 , U11^#_0(11, 5) -> 24 , U11^#_0(11, 7) -> 24 , U11^#_0(11, 11) -> 24 , U11^#_0(11, 13) -> 24 , U11^#_0(13, 2) -> 24 , U11^#_0(13, 3) -> 24 , U11^#_0(13, 5) -> 24 , U11^#_0(13, 7) -> 24 , U11^#_0(13, 11) -> 24 , U11^#_0(13, 13) -> 24 , proper^#_0(2) -> 36 , proper^#_0(3) -> 36 , proper^#_0(5) -> 36 , proper^#_0(7) -> 36 , proper^#_0(11) -> 36 , proper^#_0(13) -> 36} 18) {proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2)))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2)))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [1] x1 + [1] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2)))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_15() = [0] c_16(x1) = [1] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [8] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [8] length(x1) = [1] x1 + [2] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [11] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [13] c_15() = [0] c_16(x1) = [1] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(cons(X1, X2)) -> c_16(cons^#(proper(X1), proper(X2))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(11) -> 3 , mark_0(13) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 11 , ok_0(2) -> 13 , ok_0(3) -> 13 , ok_0(5) -> 13 , ok_0(7) -> 13 , ok_0(11) -> 13 , ok_0(13) -> 13 , cons^#_0(2, 2) -> 17 , cons^#_0(2, 3) -> 17 , cons^#_0(2, 5) -> 17 , cons^#_0(2, 7) -> 17 , cons^#_0(2, 11) -> 17 , cons^#_0(2, 13) -> 17 , cons^#_0(3, 2) -> 17 , cons^#_0(3, 3) -> 17 , cons^#_0(3, 5) -> 17 , cons^#_0(3, 7) -> 17 , cons^#_0(3, 11) -> 17 , cons^#_0(3, 13) -> 17 , cons^#_0(5, 2) -> 17 , cons^#_0(5, 3) -> 17 , cons^#_0(5, 5) -> 17 , cons^#_0(5, 7) -> 17 , cons^#_0(5, 11) -> 17 , cons^#_0(5, 13) -> 17 , cons^#_0(7, 2) -> 17 , cons^#_0(7, 3) -> 17 , cons^#_0(7, 5) -> 17 , cons^#_0(7, 7) -> 17 , cons^#_0(7, 11) -> 17 , cons^#_0(7, 13) -> 17 , cons^#_0(11, 2) -> 17 , cons^#_0(11, 3) -> 17 , cons^#_0(11, 5) -> 17 , cons^#_0(11, 7) -> 17 , cons^#_0(11, 11) -> 17 , cons^#_0(11, 13) -> 17 , cons^#_0(13, 2) -> 17 , cons^#_0(13, 3) -> 17 , cons^#_0(13, 5) -> 17 , cons^#_0(13, 7) -> 17 , cons^#_0(13, 11) -> 17 , cons^#_0(13, 13) -> 17 , proper^#_0(2) -> 36 , proper^#_0(3) -> 36 , proper^#_0(5) -> 36 , proper^#_0(7) -> 36 , proper^#_0(11) -> 36 , proper^#_0(13) -> 36} 19) {proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2)))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2)))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2)))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [1] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [8] cons(x1, x2) = [1] x1 + [1] x2 + [8] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [2] s(x1) = [1] x1 + [8] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [3] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [1] x1 + [4] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(U12(X1, X2)) -> c_20(U12^#(proper(X1), proper(X2))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(11) -> 3 , mark_0(13) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 11 , ok_0(2) -> 13 , ok_0(3) -> 13 , ok_0(5) -> 13 , ok_0(7) -> 13 , ok_0(11) -> 13 , ok_0(13) -> 13 , U12^#_0(2, 2) -> 19 , U12^#_0(2, 3) -> 19 , U12^#_0(2, 5) -> 19 , U12^#_0(2, 7) -> 19 , U12^#_0(2, 11) -> 19 , U12^#_0(2, 13) -> 19 , U12^#_0(3, 2) -> 19 , U12^#_0(3, 3) -> 19 , U12^#_0(3, 5) -> 19 , U12^#_0(3, 7) -> 19 , U12^#_0(3, 11) -> 19 , U12^#_0(3, 13) -> 19 , U12^#_0(5, 2) -> 19 , U12^#_0(5, 3) -> 19 , U12^#_0(5, 5) -> 19 , U12^#_0(5, 7) -> 19 , U12^#_0(5, 11) -> 19 , U12^#_0(5, 13) -> 19 , U12^#_0(7, 2) -> 19 , U12^#_0(7, 3) -> 19 , U12^#_0(7, 5) -> 19 , U12^#_0(7, 7) -> 19 , U12^#_0(7, 11) -> 19 , U12^#_0(7, 13) -> 19 , U12^#_0(11, 2) -> 19 , U12^#_0(11, 3) -> 19 , U12^#_0(11, 5) -> 19 , U12^#_0(11, 7) -> 19 , U12^#_0(11, 11) -> 19 , U12^#_0(11, 13) -> 19 , U12^#_0(13, 2) -> 19 , U12^#_0(13, 3) -> 19 , U12^#_0(13, 5) -> 19 , U12^#_0(13, 7) -> 19 , U12^#_0(13, 11) -> 19 , U12^#_0(13, 13) -> 19 , proper^#_0(2) -> 36 , proper^#_0(3) -> 36 , proper^#_0(5) -> 36 , proper^#_0(7) -> 36 , proper^#_0(11) -> 36 , proper^#_0(13) -> 36} 20) {proper^#(length(X)) -> c_22(length^#(proper(X)))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(length(X)) -> c_22(length^#(proper(X)))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [4] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(length(X)) -> c_22(length^#(proper(X)))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(length(X)) -> c_22(length^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { proper^#(length(X)) -> c_22(length^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [1] mark(x1) = [1] x1 + [8] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [8] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(length(X)) -> c_22(length^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(length(X)) -> c_22(length^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(11) -> 3 , mark_0(13) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 11 , ok_0(2) -> 13 , ok_0(3) -> 13 , ok_0(5) -> 13 , ok_0(7) -> 13 , ok_0(11) -> 13 , ok_0(13) -> 13 , length^#_0(2) -> 30 , length^#_0(3) -> 30 , length^#_0(5) -> 30 , length^#_0(7) -> 30 , length^#_0(11) -> 30 , length^#_0(13) -> 30 , proper^#_0(2) -> 36 , proper^#_0(3) -> 36 , proper^#_0(5) -> 36 , proper^#_0(7) -> 36 , proper^#_0(11) -> 36 , proper^#_0(13) -> 36} 21) {proper^#(s(X)) -> c_21(s^#(proper(X)))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(s(X)) -> c_21(s^#(proper(X)))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [4] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(s(X)) -> c_21(s^#(proper(X)))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(s(X)) -> c_21(s^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { proper^#(s(X)) -> c_21(s^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [1] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [1] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [2] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [12] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [6] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(s(X)) -> c_21(s^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(U11(X1, X2)) -> U11(proper(X1), proper(X2)) , proper(U12(X1, X2)) -> U12(proper(X1), proper(X2)) , proper(s(X)) -> s(proper(X)) , proper(length(X)) -> length(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , U11(mark(X1), X2) -> mark(U11(X1, X2)) , U12(mark(X1), X2) -> mark(U12(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(s(X)) -> c_21(s^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , U11(ok(X1), ok(X2)) -> ok(U11(X1, X2)) , U12(ok(X1), ok(X2)) -> ok(U12(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(11) -> 3 , mark_0(13) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 11 , ok_0(2) -> 13 , ok_0(3) -> 13 , ok_0(5) -> 13 , ok_0(7) -> 13 , ok_0(11) -> 13 , ok_0(13) -> 13 , s^#_0(2) -> 21 , s^#_0(3) -> 21 , s^#_0(5) -> 21 , s^#_0(7) -> 21 , s^#_0(11) -> 21 , s^#_0(13) -> 21 , proper^#_0(2) -> 36 , proper^#_0(3) -> 36 , proper^#_0(5) -> 36 , proper^#_0(7) -> 36 , proper^#_0(11) -> 36 , proper^#_0(13) -> 36} 22) { active^#(U12(tt(), L)) -> c_2(s^#(length(L))) , s^#(ok(X)) -> c_27(s^#(X)) , s^#(mark(X)) -> c_13(s^#(X))} The usable rules for this path are the following: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , active^#(U12(tt(), L)) -> c_2(s^#(length(L))) , s^#(ok(X)) -> c_27(s^#(X)) , s^#(mark(X)) -> c_13(s^#(X))} Details: We apply the weight gap principle, strictly orienting the rules {active^#(U12(tt(), L)) -> c_2(s^#(length(L)))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U12(tt(), L)) -> c_2(s^#(length(L)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [1] x1 + [1] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [1] x1 + [0] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {s^#(ok(X)) -> c_27(s^#(X))} and weakly orienting the rules {active^#(U12(tt(), L)) -> c_2(s^#(length(L)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {s^#(ok(X)) -> c_27(s^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [8] U12(x1, x2) = [1] x1 + [1] x2 + [10] s(x1) = [0] x1 + [0] length(x1) = [1] x1 + [1] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [1] x1 + [7] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {s^#(mark(X)) -> c_13(s^#(X))} and weakly orienting the rules { s^#(ok(X)) -> c_27(s^#(X)) , active^#(U12(tt(), L)) -> c_2(s^#(length(L)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {s^#(mark(X)) -> c_13(s^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [8] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [1] x1 + [1] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [1] x1 + [0] s^#(x1) = [1] x1 + [8] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [1] x1 + [1] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [1] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X))} Weak Rules: { s^#(mark(X)) -> c_13(s^#(X)) , s^#(ok(X)) -> c_27(s^#(X)) , active^#(U12(tt(), L)) -> c_2(s^#(length(L)))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X))} Weak Rules: { s^#(mark(X)) -> c_13(s^#(X)) , s^#(ok(X)) -> c_27(s^#(X)) , active^#(U12(tt(), L)) -> c_2(s^#(length(L)))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(7) -> 3 , mark_0(13) -> 3 , tt_0() -> 7 , ok_0(3) -> 13 , ok_0(7) -> 13 , ok_0(13) -> 13 , active^#_0(3) -> 15 , active^#_0(7) -> 15 , active^#_0(13) -> 15 , s^#_0(3) -> 21 , s^#_0(7) -> 21 , s^#_0(13) -> 21 , c_13_0(21) -> 21 , c_27_0(21) -> 21} 23) {active^#(U12(tt(), L)) -> c_2(s^#(length(L)))} The usable rules for this path are the following: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , active^#(U12(tt(), L)) -> c_2(s^#(length(L)))} Details: We apply the weight gap principle, strictly orienting the rules {active^#(U12(tt(), L)) -> c_2(s^#(length(L)))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U12(tt(), L)) -> c_2(s^#(length(L)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [1] x1 + [1] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [1] x1 + [1] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [1] x1 + [1] s^#(x1) = [1] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X))} Weak Rules: {active^#(U12(tt(), L)) -> c_2(s^#(length(L)))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X))} Weak Rules: {active^#(U12(tt(), L)) -> c_2(s^#(length(L)))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(7) -> 3 , mark_0(13) -> 3 , tt_0() -> 7 , ok_0(3) -> 13 , ok_0(7) -> 13 , ok_0(13) -> 13 , active^#_0(3) -> 15 , active^#_0(7) -> 15 , active^#_0(13) -> 15 , s^#_0(3) -> 21 , s^#_0(7) -> 21 , s^#_0(13) -> 21} 24) {active^#(U11(tt(), L)) -> c_1(U12^#(tt(), L))} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [0] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(U11(tt(), L)) -> c_1(U12^#(tt(), L))} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(U11(tt(), L)) -> c_1(U12^#(tt(), L))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(U11(tt(), L)) -> c_1(U12^#(tt(), L))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [0] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [1] x1 + [0] U12^#(x1, x2) = [1] x1 + [1] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(U11(tt(), L)) -> c_1(U12^#(tt(), L))} Details: The given problem does not contain any strict rules 25) {active^#(zeros()) -> c_0(cons^#(0(), zeros()))} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [0] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(zeros()) -> c_0(cons^#(0(), zeros()))} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(zeros()) -> c_0(cons^#(0(), zeros()))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(zeros()) -> c_0(cons^#(0(), zeros()))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [0] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [1] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(zeros()) -> c_0(cons^#(0(), zeros()))} Details: The given problem does not contain any strict rules 26) {active^#(length(cons(N, L))) -> c_4(U11^#(tt(), L))} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [0] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(length(cons(N, L))) -> c_4(U11^#(tt(), L))} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(length(cons(N, L))) -> c_4(U11^#(tt(), L))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(length(cons(N, L))) -> c_4(U11^#(tt(), L))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [1] x1 + [0] U11^#(x1, x2) = [1] x1 + [1] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(length(cons(N, L))) -> c_4(U11^#(tt(), L))} Details: The given problem does not contain any strict rules 27) {active^#(length(nil())) -> c_3()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [0] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(length(nil())) -> c_3()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(length(nil())) -> c_3()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(length(nil())) -> c_3()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [1] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(length(nil())) -> c_3()} Details: The given problem does not contain any strict rules 28) {proper^#(tt()) -> c_19()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [0] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {proper^#(tt()) -> c_19()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {proper^#(tt()) -> c_19()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(tt()) -> c_19()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [0] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {proper^#(tt()) -> c_19()} Details: The given problem does not contain any strict rules 29) {proper^#(zeros()) -> c_15()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [0] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {proper^#(zeros()) -> c_15()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {proper^#(zeros()) -> c_15()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(zeros()) -> c_15()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [0] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {proper^#(zeros()) -> c_15()} Details: The given problem does not contain any strict rules 30) {proper^#(0()) -> c_17()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [0] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {proper^#(0()) -> c_17()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {proper^#(0()) -> c_17()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(0()) -> c_17()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [0] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {proper^#(0()) -> c_17()} Details: The given problem does not contain any strict rules 31) {proper^#(nil()) -> c_23()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [0] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {proper^#(nil()) -> c_23()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {proper^#(nil()) -> c_23()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(nil()) -> c_23()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] U11(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] U12(x1, x2) = [0] x1 + [0] x2 + [0] s(x1) = [0] x1 + [0] length(x1) = [0] x1 + [0] nil() = [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1(x1) = [0] x1 + [0] U12^#(x1, x2) = [0] x1 + [0] x2 + [0] c_2(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_3() = [0] c_4(x1) = [0] x1 + [0] U11^#(x1, x2) = [0] x1 + [0] x2 + [0] c_5(x1) = [0] x1 + [0] c_6(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] c_12(x1) = [0] x1 + [0] c_13(x1) = [0] x1 + [0] c_14(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_15() = [0] c_16(x1) = [0] x1 + [0] c_17() = [0] c_18(x1) = [0] x1 + [0] c_19() = [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23() = [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] c_26(x1) = [0] x1 + [0] c_27(x1) = [0] x1 + [0] c_28(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_29(x1) = [0] x1 + [0] c_30(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {proper^#(nil()) -> c_23()} Details: The given problem does not contain any strict rules